home *** CD-ROM | disk | FTP | other *** search
/ Workbench Add-On / Workbench Add-On - Volume 1.iso / Gfx / Edit / TSMorph / src / jpeg_ls / jrdgif.c < prev    next >
C/C++ Source or Header  |  1994-10-30  |  21KB  |  635 lines
  1. /*
  2.  * jrdgif.c
  3.  *
  4.  * Copyright (C) 1991, 1992, Thomas G. Lane.
  5.  * This file is part of the Independent JPEG Group's software.
  6.  * For conditions of distribution and use, see the accompanying README file.
  7.  *
  8.  * This file contains routines to read input images in GIF format.
  9.  *
  10.  * These routines may need modification for non-Unix environments or
  11.  * specialized applications.  As they stand, they assume input from
  12.  * an ordinary stdio stream.  They further assume that reading begins
  13.  * at the start of the file; input_init may need work if the
  14.  * user interface has already read some data (e.g., to determine that
  15.  * the file is indeed GIF format).
  16.  *
  17.  * These routines are invoked via the methods get_input_row
  18.  * and input_init/term.
  19.  */
  20.  
  21. /*
  22.  * This code is loosely based on giftoppm from the PBMPLUS distribution
  23.  * of Feb. 1991.  That file contains the following copyright notice:
  24.  * +-------------------------------------------------------------------+
  25.  * | Copyright 1990, David Koblas.                                     |
  26.  * |   Permission to use, copy, modify, and distribute this software   |
  27.  * |   and its documentation for any purpose and without fee is hereby |
  28.  * |   granted, provided that the above copyright notice appear in all |
  29.  * |   copies and that both that copyright notice and this permission  |
  30.  * |   notice appear in supporting documentation.  This software is    |
  31.  * |   provided "as is" without express or implied warranty.           |
  32.  * +-------------------------------------------------------------------+
  33.  *
  34.  * We are also required to state that
  35.  *    "The Graphics Interchange Format(c) is the Copyright property of
  36.  *    CompuServe Incorporated. GIF(sm) is a Service Mark property of
  37.  *    CompuServe Incorporated."
  38.  */
  39.  
  40. #include "jinclude.h"
  41.  
  42. #ifdef GIF_SUPPORTED
  43.  
  44.  
  45. #define    MAXCOLORMAPSIZE    256    /* max # of colors in a GIF colormap */
  46. #define NUMCOLORS    3    /* # of colors */
  47. #define CM_RED        0    /* color component numbers */
  48. #define CM_GREEN    1
  49. #define CM_BLUE        2
  50.  
  51. static JSAMPARRAY colormap;    /* the colormap to use */
  52. /* colormap[i][j] = value of i'th color component for pixel value j */
  53.  
  54. #define    MAX_LZW_BITS    12    /* maximum LZW code size */
  55. #define LZW_TABLE_SIZE    (1<<MAX_LZW_BITS) /* # of possible LZW symbols */
  56.  
  57. /* Macros for extracting header data --- note we assume chars may be signed */
  58.  
  59. #define LM_to_uint(a,b)        ((((b)&0xFF) << 8) | ((a)&0xFF))
  60.  
  61. #define BitSet(byte, bit)    ((byte) & (bit))
  62. #define INTERLACE    0x40    /* mask for bit signifying interlaced image */
  63. #define COLORMAPFLAG    0x80    /* mask for bit signifying colormap presence */
  64.  
  65. #define    ReadOK(file,buffer,len)    (JFREAD(file,buffer,len) == ((size_t) (len)))
  66.  
  67. /* Static vars for GetCode and LZWReadByte */
  68.  
  69. static char code_buf[256+4];    /* current input data block */
  70. static int last_byte;        /* # of bytes in code_buf */
  71. static int last_bit;        /* # of bits in code_buf */
  72. static int cur_bit;        /* next bit index to read */
  73. static boolean out_of_blocks;    /* TRUE if hit terminator data block */
  74.  
  75. static int input_code_size;    /* codesize given in GIF file */
  76. static int clear_code,end_code; /* values for Clear and End codes */
  77.  
  78. static int code_size;        /* current actual code size */
  79. static int limit_code;        /* 2^code_size */
  80. static int max_code;        /* first unused code value */
  81. static boolean first_time;    /* flags first call to LZWReadByte */
  82.  
  83. /* LZW decompression tables:
  84.  *   symbol_head[K] = prefix symbol of any LZW symbol K (0..LZW_TABLE_SIZE-1)
  85.  *   symbol_tail[K] = suffix byte   of any LZW symbol K (0..LZW_TABLE_SIZE-1)
  86.  * Note that entries 0..end_code of the above tables are not used,
  87.  * since those symbols represent raw bytes or special codes.
  88.  *
  89.  * The stack represents the not-yet-used expansion of the last LZW symbol.
  90.  * In the worst case, a symbol could expand to as many bytes as there are
  91.  * LZW symbols, so we allocate LZW_TABLE_SIZE bytes for the stack.
  92.  * (This is conservative since that number includes the raw-byte symbols.)
  93.  *
  94.  * The tables are allocated from FAR heap space since they would use up
  95.  * rather a lot of the near data space in a PC.
  96.  */
  97.  
  98. static UINT16 FAR *symbol_head; /* => table of prefix symbols */
  99. static UINT8  FAR *symbol_tail; /* => table of suffix bytes */
  100. static UINT8  FAR *symbol_stack; /* stack for symbol expansions */
  101. static UINT8  FAR *sp;        /* stack pointer */
  102.  
  103. /* Static state for interlaced image processing */
  104.  
  105. static boolean is_interlaced;    /* TRUE if have interlaced image */
  106. static big_sarray_ptr interlaced_image;    /* full image in interlaced order */
  107. static long cur_row_number;    /* need to know actual row number */
  108. static long pass2_offset;    /* # of pixel rows in pass 1 */
  109. static long pass3_offset;    /* # of pixel rows in passes 1&2 */
  110. static long pass4_offset;    /* # of pixel rows in passes 1,2,3 */
  111.  
  112.  
  113. /* Forward declarations */
  114. METHODDEF void load_interlaced_image PP((decompress_info_ptr cinfo, JSAMPARRAY pixel_row));
  115. METHODDEF void get_interlaced_row PP((decompress_info_ptr cinfo, JSAMPARRAY pixel_row));
  116.  
  117.  
  118.  
  119. LOCAL int
  120. ReadByte (decompress_info_ptr cinfo)
  121. /* Read next byte from GIF file */
  122. {
  123. #ifdef AMIGA_IO
  124.   BPTR infile = cinfo->input_file;
  125. #else
  126.   register FILE * infile = cinfo->input_file;
  127. #endif
  128.   int c;
  129.  
  130.   if ((c = getc(infile)) == EOF)
  131.     ERREXIT(cinfo->emethods, "Premature EOF in GIF file");
  132.   return c;
  133. }
  134.  
  135.  
  136. LOCAL int
  137. GetDataBlock (decompress_info_ptr cinfo, char *buf)
  138. /* Read a GIF data block, which has a leading count byte */
  139. /* A zero-length block marks the end of a data block sequence */
  140. {
  141.   int count;
  142.  
  143.   count = ReadByte(cinfo);
  144.   if (count > 0) {
  145.     if (! ReadOK(cinfo->input_file, buf, count))
  146.       ERREXIT(cinfo->emethods, "Premature EOF in GIF file");
  147.   }
  148.   return count;
  149. }
  150.  
  151.  
  152. LOCAL void
  153. SkipDataBlocks (decompress_info_ptr cinfo)
  154. /* Skip a series of data blocks, until a block terminator is found */
  155. {
  156.   char buf[256];
  157.  
  158.   while (GetDataBlock(cinfo, buf) > 0)
  159.     /* skip */;
  160. }
  161.  
  162.  
  163. LOCAL void
  164. ReInitLZW (void)
  165. /* (Re)initialize LZW state; shared code for startup and Clear processing */
  166. {
  167.   code_size = input_code_size+1;
  168.   limit_code = clear_code << 1;    /* 2^code_size */
  169.   max_code = clear_code + 2;    /* first unused code value */
  170.   sp = symbol_stack;        /* init stack to empty */
  171. }
  172.  
  173.  
  174. LOCAL void
  175. InitLZWCode (void)
  176. /* Initialize for a series of LZWReadByte (and hence GetCode) calls */
  177. {
  178.   /* GetCode initialization */
  179.   last_byte = 2;        /* make safe to "recopy last two bytes" */
  180.   last_bit = 0;            /* nothing in the buffer */
  181.   cur_bit = 0;            /* force buffer load on first call */
  182.   out_of_blocks = FALSE;
  183.  
  184.   /* LZWReadByte initialization */
  185.   clear_code = 1 << input_code_size; /* compute special code values */
  186.   end_code = clear_code + 1;    /* note that these do not change */
  187.   first_time = TRUE;
  188.   ReInitLZW();
  189. }
  190.  
  191.  
  192. LOCAL int
  193. GetCode (decompress_info_ptr cinfo)
  194. /* Fetch the next code_size bits from the GIF data */
  195. /* We assume code_size is less than 16 */
  196. {
  197.   register INT32 accum;
  198.   int offs, ret, count;
  199.  
  200.   if ( (cur_bit+code_size) > last_bit) {
  201.     /* Time to reload the buffer */
  202.     if (out_of_blocks) {
  203.       WARNMS(cinfo->emethods, "Ran out of GIF bits");
  204.       return end_code;        /* fake something useful */
  205.     }
  206.     /* preserve last two bytes of what we have -- assume code_size <= 16 */
  207.     code_buf[0] = code_buf[last_byte-2];
  208.     code_buf[1] = code_buf[last_byte-1];
  209.     /* Load more bytes; set flag if we reach the terminator block */
  210.     if ((count = GetDataBlock(cinfo, &code_buf[2])) == 0) {
  211.       out_of_blocks = TRUE;
  212.       WARNMS(cinfo->emethods, "Ran out of GIF bits");
  213.       return end_code;        /* fake something useful */
  214.     }
  215.     /* Reset counters */
  216.     cur_bit = (cur_bit - last_bit) + 16;
  217.     last_byte = 2 + count;
  218.     last_bit = last_byte * 8;
  219.   }
  220.  
  221.   /* Form up next 24 bits in accum */
  222.   offs = cur_bit >> 3;        /* byte containing cur_bit */
  223. #ifdef CHAR_IS_UNSIGNED
  224.   accum = code_buf[offs+2];
  225.   accum <<= 8;
  226.   accum |= code_buf[offs+1];
  227.   accum <<= 8;
  228.   accum |= code_buf[offs];
  229. #else
  230.   accum = code_buf[offs+2] & 0xFF;
  231.   accum <<= 8;
  232.   accum |= code_buf[offs+1] & 0xFF;
  233.   accum <<= 8;
  234.   accum |= code_buf[offs] & 0xFF;
  235. #endif
  236.  
  237.   /* Right-align cur_bit in accum, then mask off desired number of bits */
  238.   accum >>= (cur_bit & 7);
  239.   ret = ((int) accum) & ((1 << code_size) - 1);
  240.   
  241.   cur_bit += code_size;
  242.   return ret;
  243. }
  244.  
  245.  
  246. LOCAL int
  247. LZWReadByte (decompress_info_ptr cinfo)
  248. /* Read an LZW-compressed byte */
  249. {
  250.   static int oldcode;        /* previous LZW symbol */
  251.   static int firstcode;        /* first byte of oldcode's expansion */
  252.   register int code;        /* current working code */
  253.   int incode;            /* saves actual input code */
  254.  
  255.   /* First time, just eat the expected Clear code(s) and return next code, */
  256.   /* which is expected to be a raw byte. */
  257.   if (first_time) {
  258.     first_time = FALSE;
  259.     code = clear_code;        /* enables sharing code with Clear case */
  260.   } else {
  261.  
  262.     /* If any codes are stacked from a previously read symbol, return them */
  263.     if (sp > symbol_stack)
  264.       return (int) *(--sp);
  265.  
  266.     /* Time to read a new symbol */
  267.     code = GetCode(cinfo);
  268.  
  269.   }
  270.  
  271.   if (code == clear_code) {
  272.     /* Reinit static state, swallow any extra Clear codes, and */
  273.     /* return next code, which is expected to be a raw byte. */
  274.     ReInitLZW();
  275.     do {
  276.       code = GetCode(cinfo);
  277.     } while (code == clear_code);
  278.     if (code > clear_code) {    /* make sure it is a raw byte */
  279.       WARNMS(cinfo->emethods, "Corrupt data in GIF file");
  280.       code = 0;            /* use something valid */
  281.     }
  282.     firstcode = oldcode = code;    /* make firstcode, oldcode valid! */
  283.     return code;
  284.   }
  285.  
  286.   if (code == end_code) {
  287.     /* Skip the rest of the image, unless GetCode already read terminator */
  288.     if (! out_of_blocks) {
  289.       SkipDataBlocks(cinfo);
  290.       out_of_blocks = TRUE;
  291.     }
  292.     /* Complain that there's not enough data */
  293.     WARNMS(cinfo->emethods, "Premature end of GIF image");
  294.     /* Pad data with 0's */
  295.     return 0;            /* fake something usable */
  296.   }
  297.  
  298.   /* Got normal raw byte or LZW symbol */
  299.   incode = code;        /* save for a moment */
  300.   
  301.   if (code >= max_code) {    /* special case for not-yet-defined symbol */
  302.     /* code == max_code is OK; anything bigger is bad data */
  303.     if (code > max_code) {
  304.       WARNMS(cinfo->emethods, "Corrupt data in GIF file");
  305.       incode = 0;        /* prevent creation of loops in symbol table */
  306.     }
  307.     *sp++ = (UINT8) firstcode;    /* it will be defined as oldcode/firstcode */
  308.     code = oldcode;
  309.   }
  310.  
  311.   /* If it's a symbol, expand it into the stack */
  312.   while (code >= clear_code) {
  313.     *sp++ = symbol_tail[code];    /* tail of symbol: a simple byte value */
  314.     code = symbol_head[code];    /* head of symbol: another LZW symbol */
  315.   }
  316.   /* At this point code just represents a raw byte */
  317.   firstcode = code;        /* save for possible future use */
  318.  
  319.   /* If there's room in table, */
  320.   if ((code = max_code) < LZW_TABLE_SIZE) {
  321.     /* Define a new symbol = prev sym + head of this sym's expansion */
  322.     symbol_head[code] = oldcode;
  323.     symbol_tail[code] = (UINT8) firstcode;
  324.     max_code++;
  325.     /* Is it time to increase code_size? */
  326.     if ((max_code >= limit_code) && (code_size < MAX_LZW_BITS)) {
  327.       code_size++;
  328.       limit_code <<= 1;        /* keep equal to 2^code_size */
  329.     }
  330.   }
  331.   
  332.   oldcode = incode;        /* save last input symbol for future use */
  333.   return firstcode;        /* return first byte of symbol's expansion */
  334. }
  335.  
  336.  
  337. LOCAL void
  338. ReadColorMap (decompress_info_ptr cinfo, int cmaplen, JSAMPARRAY cmap)
  339. /* Read a GIF colormap */
  340. {
  341.   int i;
  342.  
  343.   for (i = 0; i < cmaplen; i++) {
  344.     cmap[CM_RED][i]   = (JSAMPLE) ReadByte(cinfo);
  345.     cmap[CM_GREEN][i] = (JSAMPLE) ReadByte(cinfo);
  346.     cmap[CM_BLUE][i]  = (JSAMPLE) ReadByte(cinfo);
  347.   }
  348. }
  349.  
  350.  
  351. LOCAL void
  352. DoExtension (decompress_info_ptr cinfo)
  353. /* Process an extension block */
  354. /* Currently we ignore 'em all */
  355. {
  356.   int extlabel;
  357.  
  358.   /* Read extension label byte */
  359.   extlabel = ReadByte(cinfo);
  360.   TRACEMS1(cinfo->emethods, 1, "Ignoring GIF extension block of type 0x%02x",
  361.        extlabel);
  362.   /* Skip the data block(s) associated with the extension */
  363.   SkipDataBlocks(cinfo);
  364. }
  365.  
  366.  
  367. /*
  368.  * Read the file header; return image size and component count.
  369.  */
  370.  
  371. METHODDEF void
  372. input_init (decompress_info_ptr cinfo)
  373. {
  374.   char hdrbuf[10];        /* workspace for reading control blocks */
  375.   UINT16 width, height;        /* image dimensions */
  376.   int colormaplen, aspectRatio;
  377.   int c;
  378.  
  379.   /* Allocate space to store the colormap */
  380.   colormap = (*cinfo->emethods->alloc_small_sarray)
  381.         ((long) MAXCOLORMAPSIZE, (long) NUMCOLORS);
  382.  
  383.   /* Read and verify GIF Header */
  384.   if (! ReadOK(cinfo->input_file, hdrbuf, 6))
  385.     ERREXIT(cinfo->emethods, "Not a GIF file");
  386.   if (hdrbuf[0] != 'G' || hdrbuf[1] != 'I' || hdrbuf[2] != 'F')
  387.     ERREXIT(cinfo->emethods, "Not a GIF file");
  388.   /* Check for expected version numbers.
  389.    * If unknown version, give warning and try to process anyway;
  390.    * this is per recommendation in GIF89a standard.
  391.    */
  392.   if ((hdrbuf[3] != '8' || hdrbuf[4] != '7' || hdrbuf[5] != 'a') &&
  393.       (hdrbuf[3] != '8' || hdrbuf[4] != '9' || hdrbuf[5] != 'a'))
  394.     TRACEMS3(cinfo->emethods, 1,
  395.          "Warning: unexpected GIF version number '%c%c%c'",
  396.          hdrbuf[3], hdrbuf[4], hdrbuf[5]);
  397.  
  398.   /* Read and decipher Logical Screen Descriptor */
  399.   if (! ReadOK(cinfo->input_file, hdrbuf, 7))
  400.     ERREXIT(cinfo->emethods, "Premature EOF in GIF file");
  401.   width = LM_to_uint(hdrbuf[0],hdrbuf[1]);
  402.   height = LM_to_uint(hdrbuf[2],hdrbuf[3]);
  403.   colormaplen = 2 << (hdrbuf[4] & 0x07);
  404.   /* we ignore the color resolution, sort flag, and background color index */
  405.   aspectRatio = hdrbuf[6] & 0xFF;
  406.   if (aspectRatio != 0 && aspectRatio != 49)
  407.     TRACEMS(cinfo->emethods, 1, "Warning: nonsquare pixels in input");
  408.  
  409.   /* Read global colormap if header indicates it is present */
  410.   if (BitSet(hdrbuf[4], COLORMAPFLAG))
  411.     ReadColorMap(cinfo, colormaplen, colormap);
  412.  
  413.   /* Scan until we reach start of desired image.
  414.    * We don't currently support skipping images, but could add it easily.
  415.    */
  416.   for (;;) {
  417.     c = ReadByte(cinfo);
  418.  
  419.     if (c == ';')        /* GIF terminator?? */
  420.       ERREXIT(cinfo->emethods, "Too few images in GIF file");
  421.  
  422.     if (c == '!') {        /* Extension */
  423.       DoExtension(cinfo);
  424.       continue;
  425.     }
  426.     
  427.     if (c != ',') {        /* Not an image separator? */
  428.       TRACEMS1(cinfo->emethods, 1, "Bogus input char 0x%02x, ignoring", c);
  429.       continue;
  430.     }
  431.  
  432.     /* Read and decipher Local Image Descriptor */
  433.     if (! ReadOK(cinfo->input_file, hdrbuf, 9))
  434.       ERREXIT(cinfo->emethods, "Premature EOF in GIF file");
  435.     /* we ignore top/left position info, also sort flag */
  436.     width = LM_to_uint(hdrbuf[4],hdrbuf[5]);
  437.     height = LM_to_uint(hdrbuf[6],hdrbuf[7]);
  438.     is_interlaced = BitSet(hdrbuf[8], INTERLACE);
  439.  
  440.     /* Read local colormap if header indicates it is present */
  441.     /* Note: if we wanted to support skipping images, */
  442.     /* we'd need to skip rather than read colormap for ignored images */
  443.     if (BitSet(hdrbuf[8], COLORMAPFLAG)) {
  444.       colormaplen = 2 << (hdrbuf[8] & 0x07);
  445.       ReadColorMap(cinfo, colormaplen, colormap);
  446.     }
  447.  
  448.     input_code_size = ReadByte(cinfo); /* get minimum-code-size byte */
  449.     if (input_code_size < 2 || input_code_size >= MAX_LZW_BITS)
  450.       ERREXIT1(cinfo->emethods, "Bogus codesize %ld", input_code_size);
  451.  
  452.     /* Reached desired image, so break out of loop */
  453.     /* If we wanted to skip this image, */
  454.     /* we'd call SkipDataBlocks and then continue the loop */
  455.     break;
  456.   }
  457.  
  458.   /* Prepare to read selected image: first initialize LZW decompressor */
  459.   symbol_head = (UINT16 FAR *) (*cinfo->emethods->alloc_medium)
  460.                 (LZW_TABLE_SIZE * SIZEOF(UINT16));
  461.   symbol_tail = (UINT8 FAR *) (*cinfo->emethods->alloc_medium)
  462.                 (LZW_TABLE_SIZE * SIZEOF(UINT8));
  463.   symbol_stack = (UINT8 FAR *) (*cinfo->emethods->alloc_medium)
  464.                 (LZW_TABLE_SIZE * SIZEOF(UINT8));
  465.   InitLZWCode();
  466.  
  467.   /*
  468.    * If image is interlaced, we read it into a full-size sample array,
  469.    * decompressing as we go; then get_input_row selects rows from the
  470.    * sample array in the proper order.
  471.    */
  472.   if (is_interlaced) {
  473.     /* We request the big array now, but can't access it until the pipeline
  474.      * controller causes all the big arrays to be allocated.  Hence, the
  475.      * actual work of reading the image is postponed until the first call
  476.      * of get_input_row.
  477.      */
  478.     interlaced_image = (*cinfo->emethods->request_big_sarray)
  479.         ((long) width, (long) height, 1L);
  480.     cinfo->methods->get_input_row = load_interlaced_image;
  481.     cinfo->total_passes++;    /* count file reading as separate pass */
  482.   }
  483.  
  484.   /* Return info about the image. */
  485.   cinfo->input_components = NUMCOLORS;
  486.   cinfo->in_color_space = CS_RGB;
  487.   cinfo->image_width = width;
  488.   cinfo->image_height = height;
  489.   cinfo->data_precision = 8;    /* always, even if 12-bit JSAMPLEs */
  490.  
  491.   TRACEMS3(cinfo->emethods, 1, "%ldx%ldx%ld GIF image",
  492.        (unsigned int) width, (unsigned int) height, colormaplen);
  493. }
  494.  
  495.  
  496. /*
  497.  * Read one row of pixels.
  498.  * This version is used for noninterlaced GIF images:
  499.  * we read directly from the GIF file.
  500.  */
  501.  
  502. METHODDEF void
  503. get_input_row (decompress_info_ptr cinfo, JSAMPARRAY pixel_row)
  504. {
  505.   register JSAMPROW ptr0, ptr1, ptr2;
  506.   register long col;
  507.   register int c;
  508.   
  509.   ptr0 = pixel_row[0];
  510.   ptr1 = pixel_row[1];
  511.   ptr2 = pixel_row[2];
  512.   for (col = cinfo->image_width; col > 0; col--) {
  513.     c = LZWReadByte(cinfo);
  514.     *ptr0++ = colormap[CM_RED][c];
  515.     *ptr1++ = colormap[CM_GREEN][c];
  516.     *ptr2++ = colormap[CM_BLUE][c];
  517.   }
  518. }
  519.  
  520.  
  521. /*
  522.  * Read one row of pixels.
  523.  * This version is used for the first call on get_input_row when
  524.  * reading an interlaced GIF file: we read the whole image into memory.
  525.  */
  526.  
  527. METHODDEF void
  528. load_interlaced_image (decompress_info_ptr cinfo, JSAMPARRAY pixel_row)
  529. {
  530.   JSAMPARRAY image_ptr;
  531.   register JSAMPROW sptr;
  532.   register long col;
  533.   long row;
  534.  
  535.   /* Read the interlaced image into the big array we've created. */
  536.   for (row = 0; row < cinfo->image_height; row++) {
  537.     (*cinfo->methods->progress_monitor) (cinfo, row, cinfo->image_height);
  538.     image_ptr = (*cinfo->emethods->access_big_sarray)
  539.             (interlaced_image, row, TRUE);
  540.     sptr = image_ptr[0];
  541.     for (col = cinfo->image_width; col > 0; col--) {
  542.       *sptr++ = (JSAMPLE) LZWReadByte(cinfo);
  543.     }
  544.   }
  545.   cinfo->completed_passes++;
  546.  
  547.   /* Replace method pointer so subsequent calls don't come here. */
  548.   cinfo->methods->get_input_row = get_interlaced_row;
  549.   /* Initialize for get_interlaced_row, and perform first call on it. */
  550.   cur_row_number = 0;
  551.   pass2_offset = (cinfo->image_height + 7L) / 8L;
  552.   pass3_offset = pass2_offset + (cinfo->image_height + 3L) / 8L;
  553.   pass4_offset = pass3_offset + (cinfo->image_height + 1L) / 4L;
  554.  
  555.   get_interlaced_row(cinfo, pixel_row);
  556. }
  557.  
  558.  
  559. /*
  560.  * Read one row of pixels.
  561.  * This version is used for interlaced GIF images:
  562.  * we read from the big in-memory image.
  563.  */
  564.  
  565. METHODDEF void
  566. get_interlaced_row (decompress_info_ptr cinfo, JSAMPARRAY pixel_row)
  567. {
  568.   JSAMPARRAY image_ptr;
  569.   register JSAMPROW sptr, ptr0, ptr1, ptr2;
  570.   register long col;
  571.   register int c;
  572.   long irow;
  573.  
  574.   /* Figure out which row of interlaced image is needed, and access it. */
  575.   switch ((int) (cur_row_number & 7L)) {
  576.   case 0:            /* first-pass row */
  577.     irow = cur_row_number >> 3;
  578.     break;
  579.   case 4:            /* second-pass row */
  580.     irow = (cur_row_number >> 3) + pass2_offset;
  581.     break;
  582.   case 2:            /* third-pass row */
  583.   case 6:
  584.     irow = (cur_row_number >> 2) + pass3_offset;
  585.     break;
  586.   default:            /* fourth-pass row */
  587.     irow = (cur_row_number >> 1) + pass4_offset;
  588.     break;
  589.   }
  590.   image_ptr = (*cinfo->emethods->access_big_sarray)
  591.             (interlaced_image, irow, FALSE);
  592.   /* Scan the row, expand colormap, and output */
  593.   sptr = image_ptr[0];
  594.   ptr0 = pixel_row[0];
  595.   ptr1 = pixel_row[1];
  596.   ptr2 = pixel_row[2];
  597.   for (col = cinfo->image_width; col > 0; col--) {
  598.     c = GETJSAMPLE(*sptr++);
  599.     *ptr0++ = colormap[CM_RED][c];
  600.     *ptr1++ = colormap[CM_GREEN][c];
  601.     *ptr2++ = colormap[CM_BLUE][c];
  602.   }
  603.   cur_row_number++;        /* for next time */
  604. }
  605.  
  606.  
  607. /*
  608.  * Finish up at the end of the file.
  609.  */
  610.  
  611. METHODDEF void
  612. input_term (decompress_info_ptr cinfo)
  613. {
  614.   /* no work (we let free_all release the workspace) */
  615. }
  616.  
  617.  
  618. /*
  619.  * The method selection routine for GIF format input.
  620.  * Note that this must be called by the user interface before calling
  621.  * jpeg_compress.  If multiple input formats are supported, the
  622.  * user interface is responsible for discovering the file format and
  623.  * calling the appropriate method selection routine.
  624.  */
  625.  
  626. GLOBAL void
  627. jselrgif (decompress_info_ptr cinfo)
  628. {
  629.   cinfo->methods->input_init = input_init;
  630.   cinfo->methods->get_input_row = get_input_row; /* assume uninterlaced */
  631.   cinfo->methods->input_term = input_term;
  632. }
  633.  
  634. #endif /* GIF_SUPPORTED */
  635.